/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package comp.racer.ip;

import comp.racer.common.rn.Jogador;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Vector;

/**
 *
 * @author david
 */
public class Ranking {

    public static final int CAPACIDADE = 10;

    JpaDao<Jogador> jogadorJpaDao = new JpaDao(Jogador.class);

    public List<Jogador> buscaRanking() {

        System.out.println("Buscando Jogadores no ranking...");
        List<Jogador> ranking = getJogadorJpaDao().findAll();

        Collections.sort(ranking);
        System.out.println("Ranking recuperado!\n");
        return ranking;
    /*
     * Assinatura do Método: buscaRanking()
    Lógica da Responsabilidade: Busca no Banco de Dados a lista das 10 melhores marcas.
    [SGBD]*/

    }

    public Map<Jogador, Integer> atualizaRanking(List<Jogador> classificacaoList) {

        Map<Jogador, Integer> jogadorPosicaoRankingMap = new HashMap<Jogador, Integer>();
        List<Jogador> rankingList = getJogadorJpaDao().findAll();

        if (rankingList.size() == 0) {
            getJogadorJpaDao().insertList(classificacaoList);

            for (Jogador jogador : classificacaoList) {
                jogadorPosicaoRankingMap.put(jogador, 1 + classificacaoList.indexOf(jogador));
            }

            return jogadorPosicaoRankingMap;

        } else {

            Collections.sort(rankingList);

            for (Jogador classificacaoJogador : classificacaoList) {
                atualizarJogadorNoRanking(rankingList, classificacaoJogador, jogadorPosicaoRankingMap);

                // caso o jogador nao tenha entrado no ranking
                if (!jogadorPosicaoRankingMap.containsKey(classificacaoJogador)) {
                    jogadorPosicaoRankingMap.put(classificacaoJogador, -1);
                }
            }
            return jogadorPosicaoRankingMap;
        }


    }

    // refatoracao
    private void atualizarJogadorNoRanking(List<Jogador> rankingList, Jogador classificacaoJogador, Map<Jogador, Integer> jogadorPosicaoRankingMap) {
        int tamanhoInicialDoRanking = rankingList.size();

        for (int indexNoRanking = 0; indexNoRanking < tamanhoInicialDoRanking; indexNoRanking++) {
            Jogador rankingJogador = rankingList.get(indexNoRanking);

            if (classificacaoJogador.getCpm() > rankingJogador.getCpm()) {
                rankingList.add(indexNoRanking, classificacaoJogador);
                getJogadorJpaDao().insert(classificacaoJogador);

                // para manter a consistencia de no maximo 10 jogadores na lista
                if (rankingList.size() > Ranking.CAPACIDADE) {
                    Jogador jogadorExcluidoDoRanking = rankingList.get(rankingList.size() - 1);
                    rankingList.remove(jogadorExcluidoDoRanking);
                    getJogadorJpaDao().delete(jogadorExcluidoDoRanking);
                }

                // definindo o jogadorPosicaoRankingMap
                jogadorPosicaoRankingMap.put(classificacaoJogador, indexNoRanking + 1);
                return;
            }
        }

        if(tamanhoInicialDoRanking < Ranking.CAPACIDADE) {
            rankingList.add(tamanhoInicialDoRanking, classificacaoJogador);
            getJogadorJpaDao().insert(classificacaoJogador);

            jogadorPosicaoRankingMap.put(classificacaoJogador, tamanhoInicialDoRanking + 1);
        }
    }

    // getters e setters
    public JpaDao<Jogador> getJogadorJpaDao() {
        return jogadorJpaDao;
    }

    public void setJogadorJpaDao(JpaDao<Jogador> jogadorJpaDao) {
        this.jogadorJpaDao = jogadorJpaDao;
    }
}
